﻿#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

//一条包含字母 A - Z 的消息通过以下映射进行了 编码 ：
//'A' -> "1"
//'B' -> "2"
//...
//'Z' -> "26"
//注意，消息不能分组为(1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。
//
//给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
class Solution
{
public:
    int numDecodings(string s)
    {
        // dp[i]表示到i为结尾的编码的个数
        int n = s.size();
        vector<int> dp(n + 1);
        dp[0] = 1;
        dp[1] = s[1 - 1] != '0';
        for (int i = 2; i <= n; i++)
        {
            // 处理单独编码
            if (s[i - 1] != '0')
                dp[i] += dp[i - 1];
            // 如果和前⾯的⼀个数联合起来编码
            int tmp = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
            if (tmp >= 10 && tmp <= 26)
                dp[i] += dp[i - 2];
        }

        return dp[n];
    }
};


//有两个日期，求两个日期之间的天数，如果两个日期是连续的我们规定他们之间的天数为两天
#include <iostream>
using namespace std;

int mon[12] = { 0,31,59,90,120,151,181,212,243,273,304,334 };

bool isLeapYear(int year)
{
    return (year % 400 == 0) || ((year % 100 != 0 && year % 4 == 0));
}

int CountDay(int y, int m, int d)
{
    int sum = 0;
    for (int i = 0; i < y; i++)
    {
        if (isLeapYear(y))
            sum += 366;
        else sum += 365;
    }
    if (isLeapYear((y)))
        sum += mon[m - 1] + 1;
    else sum += mon[m - 1];

    return sum += d;
}
int main()
{
    int year1, month1, day1, year2, month2, day2;
    scanf("%4d%2d%2d", &year1, &month1, &day1);
    scanf("%4d%2d%2d", &year2, &month2, &day2);
    int sum1 = CountDay(year1, month1, day1);
    int sum2 = CountDay(year2, month2, day2);

    cout << abs(sum2 - sum1) + 1 << endl;
    return 0;
}

//给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，
//并返回移除后数组的新长度。
//
//不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
//
//元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
class Solution
{
public:
    // 1. 设置一个变量count，用来记录nums中值等于val的元素的个数
    // 2. 遍历nums数组，对于每个元素进行如下操作：
    // a. 如果num[i]等于val，说明值为val的元素出现了一次，count++
    // b. 如果nums[i]不等于元素，将nums[i]往前搬移count个位置
    // 因为nums[i]元素之前出现过count个值等于val的元素，已经被删除了
    // 因此次数需要将nums[i]往前搬移
    // 3. 返回删除之后新数组中有效元素个数
    int removeElement(vector<int>& nums, int val)
    {
        int count = 0, n = nums.size();
        for (int i = 0; i < n; i++)
        {
            if (nums[i] == val)count++;
            else nums[i - count] = nums[i];
        }

        return n - count;
    }
};

//求1 + 2 + 3 + ... + n，
//要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A ? B : C）。
// 内部类是外部类的友元
class Solution
{
public:
    class Sum
    {
    public:
        Sum()
        {
            _sum += _i;
            _i++;
        }
    };

public:
    int Sum_Solution(int n)
    {
        Sum array[n];
        return _sum;
    }
    static int _i;
    static int _sum;

};
int Solution::_i = 1;
int Solution::_sum = 0;


//给出年分m和一年中的第n天，算出第n天是几月几号。
#include <iostream>
using namespace std;

int main()
{
    int year, day;
    int mon[13] = { 31, 28, 31, 30, 31, 30, 31, 31, 30 ,31, 30, 31 };
    while (cin >> year >> day)
    {
        if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
            mon[1] = 29;
        else
            mon[1] = 28;
        for (int i = 0; i < 12; i++)
        {
            if (day <= mon[i])
            {
                printf("%04d-%02d-%02d\n", year, i + 1, day);
                break;
            }
            else
            {
                day -= mon[i];
            }
        }
    }

    return 0;
}


//设计一个程序能计算一个日期加上若干天后是什么日期。
#include <iostream>
using namespace std;

int main()
{
    int n, year, month, day, num;
    int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
    while (cin >> n)
    {
        for (int i = 0; i < n; i++)
        {
            cin >> year >> month >> day >> num;
            day += num;
            while (day > days[month - 1])
            {
                if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
                    days[1] = 29;
                else days[1] = 28;
                day -= days[month - 1];
                if (day == 0) day = 1;
                month++;
                if (month == 13)
                {
                    year++;
                    month = 1;
                }
            }
            printf("%04d-%02d-%02d\n", year, month, day);
        }
    }

    return 0;
}

//如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，
//短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。
//
//字母和数字都属于字母数字字符。
//
//给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
class Solution
{
public:
    bool isdigitorword(char ch)
    {
        return ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
    }
    bool isPalindrome(string s)
    {
        if (s.empty()) return true;
        int n = s.size();
        for (int i = 0; i < n; i++)
        {
            s[i] = tolower(s[i]); // 忽略大小写
        }

        int left = 0, right = n - 1;
        while (left < right)
        {
            while (left < right && !isdigitorword(s[left])) left++;
            while (left < right && !isdigitorword(s[right])) right--;
            if (s[left] != s[right]) return false;
            left++;
            right--;
        }

        return true;
    }
};


//给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 - 1 。
class Solution
{
public:
    int firstUniqChar(string s)
    {
        int n = s.size();
        for (int i = 0; i < n; i++)
        {
            int index = s.find(s[i]);
            int rindex = s.rfind(s[i]);
            if (index == rindex) return i;
        }

        return -1;
    }
};

class Solution
{
public:
    int firstUniqChar(string s)
    {
        unordered_map<char, int> hash;
        int n = s.size();
        for (int i = 0; i < n; i++)
        {
            hash[s[i]]++;
        }

        for (int i = 0; i < n; i++)
        {
            if (hash[s[i]] == 1)
                return i;
        }

        return -1;
    }
};

//给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，
//就反转这 2k 字符中的前 k 个字符。
//
//如果剩余字符少于 k 个，则将剩余字符全部反转。
//如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
class Solution
{
public:
    void Reverse(string& s, int left, int right)
    {
        while (left < right)
        {
            swap(s[left++], s[right--]);
        }
    }
    string reverseStr(string s, int k)
    {
        int n = s.size();
        for (int i = 0; i < n; i += 2 * k)
        {
            if (i + k < n)
                Reverse(s, i, i + k - 1);
            else
                Reverse(s, i, n - 1);
        }

        return s;
    }
};